﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Proxy;
using SIM.Geo.UI.Movil.Clases;
using SIM.Util;
using System.Text;
namespace SIM.Geo.UI.Movil.Controllers
{
    public class GeomecanicaController : BaseController
    {

        //GET: /Estructura/
        public ActionResult Index(int idSondaje)
        {
            return View();
        }

        public JsonResult Listar(int idSondaje)
        {
            using (SEGeomecanicaClient proxy = new SEGeomecanicaClient())
            {
                var lista = proxy.BuscarGeomecanicaPorSondaje1(idSondaje);
                return Json(lista, JsonRequestBehavior.AllowGet);
            }
        }

        //GET : /Estructura/DETAILS/
        public ActionResult Details(int id)
        {

            return View();
        }

        //GET: /estructura/Create

        public ActionResult Create()
        {

            return View();
            //return View();
        }

        /// <summary>
        /// Validación unica para insertar y modificar
        /// Agregado: por Edgar
        /// </summary>
        /// <param name="entidad"></param>
        /// <param name="sb"></param>
        /// <returns></returns>
        private bool Validar(Geomecanica entidad, ref  StringBuilder sb)
        {
            bool retorno = true;
            try
            {
                if (entidad.Desde >= entidad.Hasta)
                {
                    sb.AppendLine(Constantes.MensajeGenerico.MSG_VALIDA_RANGO);
                    retorno = false;
                }

                if (Convert.ToInt32(entidad.CodigoTipoJunta) == -1)
                {
                    
                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_JUNTA);
                    retorno = false;

                }
                if (Convert.ToInt32(entidad.CodigoTipoResistencia) == -1)
                {

                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_RESISTENCIA);
                    retorno = false;

                }
                if (Convert.ToInt32(entidad.CodigoTipoCalidadRoca) == -1)
                {
                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_CALIDAD);
                    retorno = false;

                }
                if (Convert.ToInt32(entidad.CodigoTipoRelleno) == -1)
                {

                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_RELLENO);
                    retorno = false;

                }

                if (Convert.ToInt32(entidad.CodigoTipoPersistencia) == -1)
                {

                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_PERSISTENCIA);
                    retorno = false;

                }
                if (Convert.ToInt32(entidad.CodigoTipoAbertura) == -1)
                {
                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_ABERTURA);
                    retorno = false;

                }
                if (Convert.ToInt32(entidad.CodigoTipoRugosidad) == -1)
                {
                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_RUGOSIDAD);
                    retorno = false;
                }
                if (Convert.ToInt32(entidad.CodigoTipoAlteracion) == -1)
                {

                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_ALTERACION);
                    retorno = false;

                }
                if (Convert.ToInt32(entidad.CodigoTipoAgua) == -1)
                {

                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_AGUA);
                    retorno = false;

                }
                if (Convert.ToInt32(entidad.CodigoTipoEspaciado) == -1)
                {
                    sb.AppendLine(Constantes.MensajeGeomecanica.MSG_SELE_ESPACIADO);
                    retorno = false;
                }
                using (var proxy = new SEGeomecanicaClient())
                {
                    int resultInterseccion = proxy.ValidarInterseccionGeomecanica(entidad.CodigoSondaje, entidad.CodigoGeomecanica, entidad.Desde, entidad.Hasta);
                    if (resultInterseccion == 1)
                    {
                        sb.AppendLine(Constantes.MensajeGenerico.MSG_VALIDA_INTERSECCION);
                        retorno = false;
                    }
                }

            }
            catch (Exception ex)
            {
                retorno = false;
                Logger.Error("Geomecanica Controller:Validar", this.UserLogon.CodigoUsuario, ex);
            }
            return retorno;
        }

        //POST: //Geomecanica /Create
        /// <summary>
        /// metodo para guardar registro Geomecanica
        /// </summary>
        /// <param name="entidad"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult Create(Geomecanica entidad)
        {
            Resultado retorno = new Resultado();
            try
            {
                bool flag_exito = true;

                //Modificado por Edgar, la validación debe ser unico para insertar y modificar
                StringBuilder sb = new StringBuilder();
                if (!this.Validar(entidad, ref sb))
                {
                    retorno.result = 0;
                    retorno.message = sb.ToString();
                    flag_exito = false;
                }

                if (flag_exito)
                {

                    var geomecanica = entidad;

                    //Modificado por Edgar, el resultado verifica si todo está ok
                    string result = string.Empty;
                    using (var proxy = new SEGeomecanicaClient())
                    {
                        //geomecanica.CodigoGeomecanica = 2;
                        geomecanica.CodigoGeologo = UserLogon.CodigoGeologo;
                        //geomecanica.Fecha;
                        //geomecanica.CodigoTipoAbertura = 1;
                        result = proxy.InsertarGeomecanica(geomecanica);
                    }

                    if (result.CompareTo("Registrado") != 0)
                    {
                        retorno.result = 0;
                        retorno.message = result;
                        flag_exito = false;
                    }
                    else
                    {
                        retorno.result = 1;
                        retorno.message = Constantes.MensajeGeomecanica.MSG_INSERT_OK;
                    }
                }

            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;
                Logger.Error("Geomecanica Controller:Create", this.UserLogon.CodigoUsuario, ex);
            }
            return Json(retorno, JsonRequestBehavior.AllowGet);
        }

        //GET: /Geomecanica/Edit/5
        /// <summary>
        /// metodo obtener el registro de geomecanica
        /// </summary>
        /// <param name="idSondaje"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public JsonResult Edit(int idSondaje, int id)
        {
            Resultado retorno = new Resultado();
            // Sondaje obj=null;


            try
            {
                //codigo muestra
                using (var proxy = new SEGeomecanicaClient())
                {
                    var obj = proxy.ObtenerGeomecanica(idSondaje, id);
                    if (obj != null)
                    {
                        using (var proxyGeo = new SEGeologoClient())
                        {
                            obj.Geologo = proxyGeo.ObtenerGeologo(obj.CodigoGeologo);
                        }
                    }
                    retorno.result = 1;
                    retorno.message = "OK";
                    retorno.data = Json(obj, JsonRequestBehavior.AllowGet);

                }
            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;
                Logger.Error("Geomecanica Controller:Editar", this.UserLogon.CodigoUsuario, ex);

            }

            return Json(retorno, JsonRequestBehavior.AllowGet);
        }

        //POST: /Muestra /Edit/5
        [HttpPost]
        public ActionResult Edit(int id, FormCollection collection)
        {
            try
            {
                //TODO: Add update logic here

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }

        //POST
        /// <summary>
        /// metodo modificar el registro de geomecanica
        /// </summary>
        /// <param name="entidad"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult Modificar(Geomecanica entidad)
        {
            Resultado retorno = new Resultado();
            try
            {
                bool flag_exito = true;

                //Modificado por Edgar, la validación debe ser unico para insertar y modificar
                StringBuilder sb = new StringBuilder();
                if (!this.Validar(entidad, ref sb))
                {
                    retorno.result = 0;
                    retorno.message = sb.ToString();
                    flag_exito = false;
                }

                if (flag_exito)
                {
                    var geomecanica = entidad;

                    //Modificado por Edgar, el resultado verifica si todo está ok
                    string result = string.Empty;
                    using (var proxy = new SEGeomecanicaClient())
                    {

                        //geomecanica.CodigoSondaje = entidad.CodigoSondaje;
                        geomecanica.CodigoGeologo = UserLogon.CodigoGeologo;
                        // geomecanica.CodigoTipoAbertura = entidad.CodigoTipoAbertura;
                        result = proxy.ModificarGeomecanica(geomecanica);
                    }

                    if (result.CompareTo("Registrado") != 0)
                    {
                        retorno.result = 0;
                        retorno.message = result;
                        flag_exito = false;
                    }
                    else
                    {
                        retorno.result = 1;
                        retorno.message = Constantes.MensajeGeomecanica.MSG_EDIT_OK;

                    }
                }

            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;
                Logger.Error("Geomecanica Controller:Modificar", this.UserLogon.CodigoUsuario, ex);
            }
            return Json(retorno, JsonRequestBehavior.AllowGet);
        }

        //

        //GET: /Muestra/delete/5

        public ActionResult Delete(int id)
        {
            return View();
        }

        //POST: /Geomecanica/Delete/5
        /// <summary>
        /// Método para eliminar registro geomecanica
        /// </summary>
        /// <param name="idSondaje"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult Delete(int idSondaje, int id)
        {
            Resultado retorno = new Resultado();
            // Sondaje obj=null;


            try
            {
                //codigo geomecanica, codigo sondaje
                using (var proxy = new SEGeomecanicaClient())
                {
                    proxy.EliminarGeomecanica(idSondaje, id);

                    retorno.result = 1;
                    retorno.message = "OK";


                }
            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;
                Logger.Error("Geomecanica Controller:Delete", this.UserLogon.CodigoUsuario, ex);

            }

            return Json(retorno, JsonRequestBehavior.AllowGet);
        }
        [HttpPost]
        public JsonResult Finalizar(int idSondaje)
        {
            Resultado retorno = new Resultado();
            // Sondaje obj=null;

            try
            {
                //codigo muestra
                string result = string.Empty;
                using (var proxy = new SESondajeClient())
                {
                    result = proxy.FinalizarCumplimiento(idSondaje, enmTipoAnalisis.Geomecanica.GetHashCode());

                }
                if (result.CompareTo("Cumplido") != 0)
                {
                    retorno.result = 0;
                    retorno.message = result;
                }
                else
                {
                    retorno.result = 1;
                    retorno.message = Constantes.MensajeGeomecanica.MSG_FINALIZAR_OK;
                }
            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = String.Format("Ocurrió un Error{0}", ex.Message);
                Logger.Error("Geomecanica Controller:Finalizar", this.UserLogon.CodigoUsuario, ex);

            }

            return Json(retorno, JsonRequestBehavior.AllowGet);

        }
        [HttpPost]
        public JsonResult obtenerHasta(int idSondaje)
        {
            double hasta = 0.00;
            try
            {

                using (var proxyHasta = new SEGeomecanicaClient())
                {
                    var datoHasta = proxyHasta.ObtenerUltimoHasta(idSondaje);
                    hasta = datoHasta;
                }

            }
            catch (Exception ex)
            {
                throw ex;

            }

            return Json(hasta, JsonRequestBehavior.AllowGet);
        }
    }
}